        -:    0:Source:/usr/include/c++/9/atomic
        -:    1:// -*- C++ -*- header.
        -:    2:
        -:    3:// Copyright (C) 2008-2019 Free Software Foundation, Inc.
        -:    4://
        -:    5:// This file is part of the GNU ISO C++ Library.  This library is free
        -:    6:// software; you can redistribute it and/or modify it under the
        -:    7:// terms of the GNU General Public License as published by the
        -:    8:// Free Software Foundation; either version 3, or (at your option)
        -:    9:// any later version.
        -:   10:
        -:   11:// This library is distributed in the hope that it will be useful,
        -:   12:// but WITHOUT ANY WARRANTY; without even the implied warranty of
        -:   13:// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        -:   14:// GNU General Public License for more details.
        -:   15:
        -:   16:// Under Section 7 of GPL version 3, you are granted additional
        -:   17:// permissions described in the GCC Runtime Library Exception, version
        -:   18:// 3.1, as published by the Free Software Foundation.
        -:   19:
        -:   20:// You should have received a copy of the GNU General Public License and
        -:   21:// a copy of the GCC Runtime Library Exception along with this program;
        -:   22:// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
        -:   23:// <http://www.gnu.org/licenses/>.
        -:   24:
        -:   25:/** @file include/atomic
        -:   26: *  This is a Standard C++ Library header.
        -:   27: */
        -:   28:
        -:   29:// Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl.
        -:   30:// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html
        -:   31:
        -:   32:#ifndef _GLIBCXX_ATOMIC
        -:   33:#define _GLIBCXX_ATOMIC 1
        -:   34:
        -:   35:#pragma GCC system_header
        -:   36:
        -:   37:#if __cplusplus < 201103L
        -:   38:# include <bits/c++0x_warning.h>
        -:   39:#else
        -:   40:
        -:   41:#include <bits/atomic_base.h>
        -:   42:#include <bits/move.h>
        -:   43:
        -:   44:namespace std _GLIBCXX_VISIBILITY(default)
        -:   45:{
        -:   46:_GLIBCXX_BEGIN_NAMESPACE_VERSION
        -:   47:
        -:   48:  /**
        -:   49:   * @addtogroup atomics
        -:   50:   * @{
        -:   51:   */
        -:   52:
        -:   53:#if __cplusplus >= 201703L
        -:   54:# define __cpp_lib_atomic_is_always_lock_free 201603
        -:   55:#endif
        -:   56:
        -:   57:  template<typename _Tp>
        -:   58:    struct atomic;
        -:   59:
        -:   60:  /// atomic<bool>
        -:   61:  // NB: No operators or fetch-operations for this type.
        -:   62:  template<>
        -:   63:  struct atomic<bool>
        -:   64:  {
        -:   65:    using value_type = bool;
        -:   66:
        -:   67:  private:
        -:   68:    __atomic_base<bool>	_M_base;
        -:   69:
        -:   70:  public:
        -:   71:    atomic() noexcept = default;
        -:   72:    ~atomic() noexcept = default;
        -:   73:    atomic(const atomic&) = delete;
        -:   74:    atomic& operator=(const atomic&) = delete;
        -:   75:    atomic& operator=(const atomic&) volatile = delete;
        -:   76:
        -:   77:    constexpr atomic(bool __i) noexcept : _M_base(__i) { }
        -:   78:
        -:   79:    bool
        -:   80:    operator=(bool __i) noexcept
        -:   81:    { return _M_base.operator=(__i); }
        -:   82:
        -:   83:    bool
        -:   84:    operator=(bool __i) volatile noexcept
        -:   85:    { return _M_base.operator=(__i); }
        -:   86:
        -:   87:    operator bool() const noexcept
        -:   88:    { return _M_base.load(); }
        -:   89:
        -:   90:    operator bool() const volatile noexcept
        -:   91:    { return _M_base.load(); }
        -:   92:
        -:   93:    bool
        -:   94:    is_lock_free() const noexcept { return _M_base.is_lock_free(); }
        -:   95:
        -:   96:    bool
        -:   97:    is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
        -:   98:
        -:   99:#if __cplusplus >= 201703L
        -:  100:    static constexpr bool is_always_lock_free = ATOMIC_BOOL_LOCK_FREE == 2;
        -:  101:#endif
        -:  102:
        -:  103:    void
        -:  104:    store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
        -:  105:    { _M_base.store(__i, __m); }
        -:  106:
        -:  107:    void
        -:  108:    store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  109:    { _M_base.store(__i, __m); }
        -:  110:
        -:  111:    bool
        -:  112:    load(memory_order __m = memory_order_seq_cst) const noexcept
        -:  113:    { return _M_base.load(__m); }
        -:  114:
        -:  115:    bool
        -:  116:    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
        -:  117:    { return _M_base.load(__m); }
        -:  118:
        -:  119:    bool
        -:  120:    exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
        -:  121:    { return _M_base.exchange(__i, __m); }
        -:  122:
        -:  123:    bool
        -:  124:    exchange(bool __i,
        -:  125:	     memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  126:    { return _M_base.exchange(__i, __m); }
        -:  127:
        -:  128:    bool
        -:  129:    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
        -:  130:			  memory_order __m2) noexcept
        -:  131:    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
        -:  132:
        -:  133:    bool
        -:  134:    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
        -:  135:			  memory_order __m2) volatile noexcept
        -:  136:    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
        -:  137:
        -:  138:    bool
        -:  139:    compare_exchange_weak(bool& __i1, bool __i2,
        -:  140:			  memory_order __m = memory_order_seq_cst) noexcept
        -:  141:    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
        -:  142:
        -:  143:    bool
        -:  144:    compare_exchange_weak(bool& __i1, bool __i2,
        -:  145:		     memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  146:    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
        -:  147:
        -:  148:    bool
        -:  149:    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
        -:  150:			    memory_order __m2) noexcept
        -:  151:    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
        -:  152:
        -:  153:    bool
        -:  154:    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
        -:  155:			    memory_order __m2) volatile noexcept
        -:  156:    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
        -:  157:
        -:  158:    bool
        -:  159:    compare_exchange_strong(bool& __i1, bool __i2,
        -:  160:			    memory_order __m = memory_order_seq_cst) noexcept
        -:  161:    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
        -:  162:
        -:  163:    bool
        -:  164:    compare_exchange_strong(bool& __i1, bool __i2,
        -:  165:		    memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  166:    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
        -:  167:  };
        -:  168:
        -:  169:
        -:  170:  /**
        -:  171:   *  @brief Generic atomic type, primary class template.
        -:  172:   *
        -:  173:   *  @tparam _Tp  Type to be made atomic, must be trivally copyable.
        -:  174:   */
        -:  175:  template<typename _Tp>
        -:  176:    struct atomic
        -:  177:    {
        -:  178:      using value_type = _Tp;
        -:  179:
        -:  180:    private:
        -:  181:      // Align 1/2/4/8/16-byte types to at least their size.
        -:  182:      static constexpr int _S_min_alignment
        -:  183:	= (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
        -:  184:	? 0 : sizeof(_Tp);
        -:  185:
        -:  186:      static constexpr int _S_alignment
        -:  187:        = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);
        -:  188:
        -:  189:      alignas(_S_alignment) _Tp _M_i;
        -:  190:
        -:  191:      static_assert(__is_trivially_copyable(_Tp),
        -:  192:		    "std::atomic requires a trivially copyable type");
        -:  193:
        -:  194:      static_assert(sizeof(_Tp) > 0,
        -:  195:		    "Incomplete or zero-sized types are not supported");
        -:  196:
        -:  197:    public:
        -:  198:      atomic() noexcept = default;
        -:  199:      ~atomic() noexcept = default;
        -:  200:      atomic(const atomic&) = delete;
        -:  201:      atomic& operator=(const atomic&) = delete;
        -:  202:      atomic& operator=(const atomic&) volatile = delete;
        -:  203:
        -:  204:      constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
        -:  205:
        -:  206:      operator _Tp() const noexcept
        -:  207:      { return load(); }
        -:  208:
        -:  209:      operator _Tp() const volatile noexcept
        -:  210:      { return load(); }
        -:  211:
        -:  212:      _Tp
        -:  213:      operator=(_Tp __i) noexcept
        -:  214:      { store(__i); return __i; }
        -:  215:
        -:  216:      _Tp
        -:  217:      operator=(_Tp __i) volatile noexcept
        -:  218:      { store(__i); return __i; }
        -:  219:
        -:  220:      bool
        -:  221:      is_lock_free() const noexcept
        -:  222:      {
        -:  223:	// Produce a fake, minimally aligned pointer.
        -:  224:	return __atomic_is_lock_free(sizeof(_M_i),
        -:  225:	    reinterpret_cast<void *>(-_S_alignment));
        -:  226:      }
        -:  227:
        -:  228:      bool
        -:  229:      is_lock_free() const volatile noexcept
        -:  230:      {
        -:  231:	// Produce a fake, minimally aligned pointer.
        -:  232:	return __atomic_is_lock_free(sizeof(_M_i),
        -:  233:	    reinterpret_cast<void *>(-_S_alignment));
        -:  234:      }
        -:  235:
        -:  236:#if __cplusplus >= 201703L
        -:  237:      static constexpr bool is_always_lock_free
        -:  238:	= __atomic_always_lock_free(sizeof(_M_i), 0);
        -:  239:#endif
        -:  240:
        -:  241:      void
        -:  242:      store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
        -:  243:      { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); }
        -:  244:
        -:  245:      void
        -:  246:      store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  247:      { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); }
        -:  248:
        -:  249:      _Tp
        -:  250:      load(memory_order __m = memory_order_seq_cst) const noexcept
        -:  251:      {
        -:  252:	alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
        -:  253:	_Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
        -:  254:	__atomic_load(std::__addressof(_M_i), __ptr, int(__m));
        -:  255:	return *__ptr;
        -:  256:      }
        -:  257:
        -:  258:      _Tp
        -:  259:      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
        -:  260:      {
        -:  261:        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
        -:  262:	_Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
        -:  263:	__atomic_load(std::__addressof(_M_i), __ptr, int(__m));
        -:  264:	return *__ptr;
        -:  265:      }
        -:  266:
        -:  267:      _Tp
        -:  268:      exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
        -:  269:      {
        -:  270:        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
        -:  271:	_Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
        -:  272:	__atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
        -:  273:			  __ptr, int(__m));
        -:  274:	return *__ptr;
        -:  275:      }
        -:  276:
        -:  277:      _Tp
        -:  278:      exchange(_Tp __i,
        -:  279:	       memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  280:      {
        -:  281:        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
        -:  282:	_Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
        -:  283:	__atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
        -:  284:			  __ptr, int(__m));
        -:  285:	return *__ptr;
        -:  286:      }
        -:  287:
        -:  288:      bool
        -:  289:      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
        -:  290:			    memory_order __f) noexcept
        -:  291:      {
        -:  292:	return __atomic_compare_exchange(std::__addressof(_M_i),
        -:  293:					 std::__addressof(__e),
        -:  294:					 std::__addressof(__i),
        -:  295:					 true, int(__s), int(__f));
        -:  296:      }
        -:  297:
        -:  298:      bool
        -:  299:      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
        -:  300:			    memory_order __f) volatile noexcept
        -:  301:      {
        -:  302:	return __atomic_compare_exchange(std::__addressof(_M_i),
        -:  303:					 std::__addressof(__e),
        -:  304:					 std::__addressof(__i),
        -:  305:					 true, int(__s), int(__f));
        -:  306:      }
        -:  307:
        -:  308:      bool
        -:  309:      compare_exchange_weak(_Tp& __e, _Tp __i,
        -:  310:			    memory_order __m = memory_order_seq_cst) noexcept
        -:  311:      { return compare_exchange_weak(__e, __i, __m,
        -:  312:                                     __cmpexch_failure_order(__m)); }
        -:  313:
        -:  314:      bool
        -:  315:      compare_exchange_weak(_Tp& __e, _Tp __i,
        -:  316:		     memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  317:      { return compare_exchange_weak(__e, __i, __m,
        -:  318:                                     __cmpexch_failure_order(__m)); }
        -:  319:
        -:  320:      bool
        -:  321:      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
        -:  322:			      memory_order __f) noexcept
        -:  323:      {
        -:  324:	return __atomic_compare_exchange(std::__addressof(_M_i),
        -:  325:					 std::__addressof(__e),
        -:  326:					 std::__addressof(__i),
        -:  327:					 false, int(__s), int(__f));
        -:  328:      }
        -:  329:
        -:  330:      bool
        -:  331:      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
        -:  332:			      memory_order __f) volatile noexcept
        -:  333:      {
        -:  334:	return __atomic_compare_exchange(std::__addressof(_M_i),
        -:  335:					 std::__addressof(__e),
        -:  336:					 std::__addressof(__i),
        -:  337:					 false, int(__s), int(__f));
        -:  338:      }
        -:  339:
        -:  340:      bool
        -:  341:      compare_exchange_strong(_Tp& __e, _Tp __i,
        -:  342:			       memory_order __m = memory_order_seq_cst) noexcept
        -:  343:      { return compare_exchange_strong(__e, __i, __m,
        -:  344:                                       __cmpexch_failure_order(__m)); }
        -:  345:
        -:  346:      bool
        -:  347:      compare_exchange_strong(_Tp& __e, _Tp __i,
        -:  348:		     memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  349:      { return compare_exchange_strong(__e, __i, __m,
        -:  350:                                       __cmpexch_failure_order(__m)); }
        -:  351:    };
        -:  352:
        -:  353:
        -:  354:  /// Partial specialization for pointer types.
        -:  355:  template<typename _Tp>
        -:  356:    struct atomic<_Tp*>
        -:  357:    {
        -:  358:      using value_type = _Tp*;
        -:  359:      using difference_type = ptrdiff_t;
        -:  360:
        -:  361:      typedef _Tp* 			__pointer_type;
        -:  362:      typedef __atomic_base<_Tp*>	__base_type;
        -:  363:      __base_type			_M_b;
        -:  364:
        -:  365:      atomic() noexcept = default;
        -:  366:      ~atomic() noexcept = default;
        -:  367:      atomic(const atomic&) = delete;
        -:  368:      atomic& operator=(const atomic&) = delete;
        -:  369:      atomic& operator=(const atomic&) volatile = delete;
        -:  370:
        -:  371:      constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
        -:  372:
        -:  373:      operator __pointer_type() const noexcept
        -:  374:      { return __pointer_type(_M_b); }
        -:  375:
        -:  376:      operator __pointer_type() const volatile noexcept
        -:  377:      { return __pointer_type(_M_b); }
        -:  378:
        -:  379:      __pointer_type
        -:  380:      operator=(__pointer_type __p) noexcept
        -:  381:      { return _M_b.operator=(__p); }
        -:  382:
        -:  383:      __pointer_type
        -:  384:      operator=(__pointer_type __p) volatile noexcept
        -:  385:      { return _M_b.operator=(__p); }
        -:  386:
        -:  387:      __pointer_type
        -:  388:      operator++(int) noexcept
        -:  389:      {
        -:  390:#if __cplusplus >= 201703L
        -:  391:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  392:#endif
        -:  393:	return _M_b++;
        -:  394:      }
        -:  395:
        -:  396:      __pointer_type
        -:  397:      operator++(int) volatile noexcept
        -:  398:      {
        -:  399:#if __cplusplus >= 201703L
        -:  400:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  401:#endif
        -:  402:	return _M_b++;
        -:  403:      }
        -:  404:
        -:  405:      __pointer_type
        -:  406:      operator--(int) noexcept
        -:  407:      {
        -:  408:#if __cplusplus >= 201703L
        -:  409:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  410:#endif
        -:  411:	return _M_b--;
        -:  412:      }
        -:  413:
        -:  414:      __pointer_type
        -:  415:      operator--(int) volatile noexcept
        -:  416:      {
        -:  417:#if __cplusplus >= 201703L
        -:  418:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  419:#endif
        -:  420:	return _M_b--;
        -:  421:      }
        -:  422:
        -:  423:      __pointer_type
        -:  424:      operator++() noexcept
        -:  425:      {
        -:  426:#if __cplusplus >= 201703L
        -:  427:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  428:#endif
        -:  429:	return ++_M_b;
        -:  430:      }
        -:  431:
        -:  432:      __pointer_type
        -:  433:      operator++() volatile noexcept
        -:  434:      {
        -:  435:#if __cplusplus >= 201703L
        -:  436:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  437:#endif
        -:  438:	return ++_M_b;
        -:  439:      }
        -:  440:
        -:  441:      __pointer_type
        -:  442:      operator--() noexcept
        -:  443:      {
        -:  444:#if __cplusplus >= 201703L
        -:  445:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  446:#endif
        -:  447:	return --_M_b;
        -:  448:      }
        -:  449:
        -:  450:      __pointer_type
        -:  451:      operator--() volatile noexcept
        -:  452:      {
        -:  453:#if __cplusplus >= 201703L
        -:  454:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  455:#endif
        -:  456:	return --_M_b;
        -:  457:      }
        -:  458:
        -:  459:      __pointer_type
        -:  460:      operator+=(ptrdiff_t __d) noexcept
        -:  461:      {
        -:  462:#if __cplusplus >= 201703L
        -:  463:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  464:#endif
        -:  465:	return _M_b.operator+=(__d);
        -:  466:      }
        -:  467:
        -:  468:      __pointer_type
        -:  469:      operator+=(ptrdiff_t __d) volatile noexcept
        -:  470:      {
        -:  471:#if __cplusplus >= 201703L
        -:  472:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  473:#endif
        -:  474:	return _M_b.operator+=(__d);
        -:  475:      }
        -:  476:
        -:  477:      __pointer_type
        -:  478:      operator-=(ptrdiff_t __d) noexcept
        -:  479:      {
        -:  480:#if __cplusplus >= 201703L
        -:  481:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  482:#endif
        -:  483:	return _M_b.operator-=(__d);
        -:  484:      }
        -:  485:
        -:  486:      __pointer_type
        -:  487:      operator-=(ptrdiff_t __d) volatile noexcept
        -:  488:      {
        -:  489:#if __cplusplus >= 201703L
        -:  490:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  491:#endif
        -:  492:	return _M_b.operator-=(__d);
        -:  493:      }
        -:  494:
        -:  495:      bool
        -:  496:      is_lock_free() const noexcept
        -:  497:      { return _M_b.is_lock_free(); }
        -:  498:
        -:  499:      bool
        -:  500:      is_lock_free() const volatile noexcept
        -:  501:      { return _M_b.is_lock_free(); }
        -:  502:
        -:  503:#if __cplusplus >= 201703L
        -:  504:    static constexpr bool is_always_lock_free = ATOMIC_POINTER_LOCK_FREE == 2;
        -:  505:#endif
        -:  506:
        -:  507:      void
        -:  508:      store(__pointer_type __p,
        -:  509:	    memory_order __m = memory_order_seq_cst) noexcept
        -:  510:      { return _M_b.store(__p, __m); }
        -:  511:
        -:  512:      void
        -:  513:      store(__pointer_type __p,
        -:  514:	    memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  515:      { return _M_b.store(__p, __m); }
        -:  516:
        -:  517:      __pointer_type
        -:  518:      load(memory_order __m = memory_order_seq_cst) const noexcept
        -:  519:      { return _M_b.load(__m); }
        -:  520:
        -:  521:      __pointer_type
        -:  522:      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
        -:  523:      { return _M_b.load(__m); }
        -:  524:
        -:  525:      __pointer_type
        -:  526:      exchange(__pointer_type __p,
        -:  527:	       memory_order __m = memory_order_seq_cst) noexcept
        -:  528:      { return _M_b.exchange(__p, __m); }
        -:  529:
        -:  530:      __pointer_type
        -:  531:      exchange(__pointer_type __p,
        -:  532:	       memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  533:      { return _M_b.exchange(__p, __m); }
        -:  534:
        -:  535:      bool
        -:  536:      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
        -:  537:			    memory_order __m1, memory_order __m2) noexcept
        -:  538:      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
        -:  539:
        -:  540:      bool
        -:  541:      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
        -:  542:			    memory_order __m1,
        -:  543:			    memory_order __m2) volatile noexcept
        -:  544:      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
        -:  545:
        -:  546:      bool
        -:  547:      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
        -:  548:			    memory_order __m = memory_order_seq_cst) noexcept
        -:  549:      {
        -:  550:	return compare_exchange_weak(__p1, __p2, __m,
        -:  551:				     __cmpexch_failure_order(__m));
        -:  552:      }
        -:  553:
        -:  554:      bool
        -:  555:      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
        -:  556:		    memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  557:      {
        -:  558:	return compare_exchange_weak(__p1, __p2, __m,
        -:  559:				     __cmpexch_failure_order(__m));
        -:  560:      }
        -:  561:
        -:  562:      bool
        -:  563:      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
        -:  564:			      memory_order __m1, memory_order __m2) noexcept
        -:  565:      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
        -:  566:
        -:  567:      bool
        -:  568:      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
        -:  569:			      memory_order __m1,
        -:  570:			      memory_order __m2) volatile noexcept
        -:  571:      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
        -:  572:
        -:  573:      bool
        -:  574:      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
        -:  575:			      memory_order __m = memory_order_seq_cst) noexcept
        -:  576:      {
        -:  577:	return _M_b.compare_exchange_strong(__p1, __p2, __m,
        -:  578:					    __cmpexch_failure_order(__m));
        -:  579:      }
        -:  580:
        -:  581:      bool
        -:  582:      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
        -:  583:		    memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  584:      {
        -:  585:	return _M_b.compare_exchange_strong(__p1, __p2, __m,
        -:  586:					    __cmpexch_failure_order(__m));
        -:  587:      }
        -:  588:
        -:  589:      __pointer_type
        -:  590:      fetch_add(ptrdiff_t __d,
        -:  591:		memory_order __m = memory_order_seq_cst) noexcept
        -:  592:      {
        -:  593:#if __cplusplus >= 201703L
        -:  594:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  595:#endif
        -:  596:	return _M_b.fetch_add(__d, __m);
        -:  597:      }
        -:  598:
        -:  599:      __pointer_type
        -:  600:      fetch_add(ptrdiff_t __d,
        -:  601:		memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  602:      {
        -:  603:#if __cplusplus >= 201703L
        -:  604:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  605:#endif
        -:  606:	return _M_b.fetch_add(__d, __m);
        -:  607:      }
        -:  608:
        -:  609:      __pointer_type
        -:  610:      fetch_sub(ptrdiff_t __d,
        -:  611:		memory_order __m = memory_order_seq_cst) noexcept
        -:  612:      {
        -:  613:#if __cplusplus >= 201703L
        -:  614:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  615:#endif
        -:  616:	return _M_b.fetch_sub(__d, __m);
        -:  617:      }
        -:  618:
        -:  619:      __pointer_type
        -:  620:      fetch_sub(ptrdiff_t __d,
        -:  621:		memory_order __m = memory_order_seq_cst) volatile noexcept
        -:  622:      {
        -:  623:#if __cplusplus >= 201703L
        -:  624:	static_assert( is_object<_Tp>::value, "pointer to object type" );
        -:  625:#endif
        -:  626:	return _M_b.fetch_sub(__d, __m);
        -:  627:      }
        -:  628:    };
        -:  629:
        -:  630:
        -:  631:  /// Explicit specialization for char.
        -:  632:  template<>
        -:  633:    struct atomic<char> : __atomic_base<char>
        -:  634:    {
        -:  635:      typedef char 			__integral_type;
        -:  636:      typedef __atomic_base<char> 	__base_type;
        -:  637:
        -:  638:      atomic() noexcept = default;
        -:  639:      ~atomic() noexcept = default;
        -:  640:      atomic(const atomic&) = delete;
        -:  641:      atomic& operator=(const atomic&) = delete;
        -:  642:      atomic& operator=(const atomic&) volatile = delete;
        -:  643:
        -:  644:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  645:
        -:  646:      using __base_type::operator __integral_type;
        -:  647:      using __base_type::operator=;
        -:  648:
        -:  649:#if __cplusplus >= 201703L
        -:  650:    static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
        -:  651:#endif
        -:  652:    };
        -:  653:
        -:  654:  /// Explicit specialization for signed char.
        -:  655:  template<>
        -:  656:    struct atomic<signed char> : __atomic_base<signed char>
        -:  657:    {
        -:  658:      typedef signed char 		__integral_type;
        -:  659:      typedef __atomic_base<signed char> 	__base_type;
        -:  660:
        -:  661:      atomic() noexcept= default;
        -:  662:      ~atomic() noexcept = default;
        -:  663:      atomic(const atomic&) = delete;
        -:  664:      atomic& operator=(const atomic&) = delete;
        -:  665:      atomic& operator=(const atomic&) volatile = delete;
        -:  666:
        -:  667:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  668:
        -:  669:      using __base_type::operator __integral_type;
        -:  670:      using __base_type::operator=;
        -:  671:
        -:  672:#if __cplusplus >= 201703L
        -:  673:    static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
        -:  674:#endif
        -:  675:    };
        -:  676:
        -:  677:  /// Explicit specialization for unsigned char.
        -:  678:  template<>
        -:  679:    struct atomic<unsigned char> : __atomic_base<unsigned char>
        -:  680:    {
        -:  681:      typedef unsigned char 		__integral_type;
        -:  682:      typedef __atomic_base<unsigned char> 	__base_type;
        -:  683:
        -:  684:      atomic() noexcept= default;
        -:  685:      ~atomic() noexcept = default;
        -:  686:      atomic(const atomic&) = delete;
        -:  687:      atomic& operator=(const atomic&) = delete;
        -:  688:      atomic& operator=(const atomic&) volatile = delete;
        -:  689:
        -:  690:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  691:
        -:  692:      using __base_type::operator __integral_type;
        -:  693:      using __base_type::operator=;
        -:  694:
        -:  695:#if __cplusplus >= 201703L
        -:  696:    static constexpr bool is_always_lock_free = ATOMIC_CHAR_LOCK_FREE == 2;
        -:  697:#endif
        -:  698:    };
        -:  699:
        -:  700:  /// Explicit specialization for short.
        -:  701:  template<>
        -:  702:    struct atomic<short> : __atomic_base<short>
        -:  703:    {
        -:  704:      typedef short 			__integral_type;
        -:  705:      typedef __atomic_base<short> 		__base_type;
        -:  706:
        -:  707:      atomic() noexcept = default;
        -:  708:      ~atomic() noexcept = default;
        -:  709:      atomic(const atomic&) = delete;
        -:  710:      atomic& operator=(const atomic&) = delete;
        -:  711:      atomic& operator=(const atomic&) volatile = delete;
        -:  712:
        -:  713:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  714:
        -:  715:      using __base_type::operator __integral_type;
        -:  716:      using __base_type::operator=;
        -:  717:
        -:  718:#if __cplusplus >= 201703L
        -:  719:    static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
        -:  720:#endif
        -:  721:    };
        -:  722:
        -:  723:  /// Explicit specialization for unsigned short.
        -:  724:  template<>
        -:  725:    struct atomic<unsigned short> : __atomic_base<unsigned short>
        -:  726:    {
        -:  727:      typedef unsigned short 	      	__integral_type;
        -:  728:      typedef __atomic_base<unsigned short> 		__base_type;
        -:  729:
        -:  730:      atomic() noexcept = default;
        -:  731:      ~atomic() noexcept = default;
        -:  732:      atomic(const atomic&) = delete;
        -:  733:      atomic& operator=(const atomic&) = delete;
        -:  734:      atomic& operator=(const atomic&) volatile = delete;
        -:  735:
        -:  736:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  737:
        -:  738:      using __base_type::operator __integral_type;
        -:  739:      using __base_type::operator=;
        -:  740:
        -:  741:#if __cplusplus >= 201703L
        -:  742:    static constexpr bool is_always_lock_free = ATOMIC_SHORT_LOCK_FREE == 2;
        -:  743:#endif
        -:  744:    };
        -:  745:
        -:  746:  /// Explicit specialization for int.
        -:  747:  template<>
        -:  748:    struct atomic<int> : __atomic_base<int>
        -:  749:    {
        -:  750:      typedef int 			__integral_type;
        -:  751:      typedef __atomic_base<int> 		__base_type;
        -:  752:
        -:  753:      atomic() noexcept = default;
        -:  754:      ~atomic() noexcept = default;
        -:  755:      atomic(const atomic&) = delete;
        -:  756:      atomic& operator=(const atomic&) = delete;
        -:  757:      atomic& operator=(const atomic&) volatile = delete;
        -:  758:
     224*:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
      224:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
_ZNSt6atomicIiEC2Ei:
    #####:  759:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
------------------
        -:  760:
        -:  761:      using __base_type::operator __integral_type;
        -:  762:      using __base_type::operator=;
        -:  763:
        -:  764:#if __cplusplus >= 201703L
        -:  765:    static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
        -:  766:#endif
        -:  767:    };
        -:  768:
        -:  769:  /// Explicit specialization for unsigned int.
        -:  770:  template<>
        -:  771:    struct atomic<unsigned int> : __atomic_base<unsigned int>
        -:  772:    {
        -:  773:      typedef unsigned int		__integral_type;
        -:  774:      typedef __atomic_base<unsigned int> 	__base_type;
        -:  775:
        -:  776:      atomic() noexcept = default;
        -:  777:      ~atomic() noexcept = default;
        -:  778:      atomic(const atomic&) = delete;
        -:  779:      atomic& operator=(const atomic&) = delete;
        -:  780:      atomic& operator=(const atomic&) volatile = delete;
        -:  781:
        -:  782:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  783:
        -:  784:      using __base_type::operator __integral_type;
        -:  785:      using __base_type::operator=;
        -:  786:
        -:  787:#if __cplusplus >= 201703L
        -:  788:    static constexpr bool is_always_lock_free = ATOMIC_INT_LOCK_FREE == 2;
        -:  789:#endif
        -:  790:    };
        -:  791:
        -:  792:  /// Explicit specialization for long.
        -:  793:  template<>
        -:  794:    struct atomic<long> : __atomic_base<long>
        -:  795:    {
        -:  796:      typedef long 			__integral_type;
        -:  797:      typedef __atomic_base<long> 	__base_type;
        -:  798:
        -:  799:      atomic() noexcept = default;
        -:  800:      ~atomic() noexcept = default;
        -:  801:      atomic(const atomic&) = delete;
        -:  802:      atomic& operator=(const atomic&) = delete;
        -:  803:      atomic& operator=(const atomic&) volatile = delete;
        -:  804:
        -:  805:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  806:
        -:  807:      using __base_type::operator __integral_type;
        -:  808:      using __base_type::operator=;
        -:  809:
        -:  810:#if __cplusplus >= 201703L
        -:  811:    static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
        -:  812:#endif
        -:  813:    };
        -:  814:
        -:  815:  /// Explicit specialization for unsigned long.
        -:  816:  template<>
        -:  817:    struct atomic<unsigned long> : __atomic_base<unsigned long>
        -:  818:    {
        -:  819:      typedef unsigned long 		__integral_type;
        -:  820:      typedef __atomic_base<unsigned long> 	__base_type;
        -:  821:
        -:  822:      atomic() noexcept = default;
        -:  823:      ~atomic() noexcept = default;
        -:  824:      atomic(const atomic&) = delete;
        -:  825:      atomic& operator=(const atomic&) = delete;
        -:  826:      atomic& operator=(const atomic&) volatile = delete;
        -:  827:
        -:  828:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  829:
        -:  830:      using __base_type::operator __integral_type;
        -:  831:      using __base_type::operator=;
        -:  832:
        -:  833:#if __cplusplus >= 201703L
        -:  834:    static constexpr bool is_always_lock_free = ATOMIC_LONG_LOCK_FREE == 2;
        -:  835:#endif
        -:  836:    };
        -:  837:
        -:  838:  /// Explicit specialization for long long.
        -:  839:  template<>
        -:  840:    struct atomic<long long> : __atomic_base<long long>
        -:  841:    {
        -:  842:      typedef long long 		__integral_type;
        -:  843:      typedef __atomic_base<long long> 		__base_type;
        -:  844:
        -:  845:      atomic() noexcept = default;
        -:  846:      ~atomic() noexcept = default;
        -:  847:      atomic(const atomic&) = delete;
        -:  848:      atomic& operator=(const atomic&) = delete;
        -:  849:      atomic& operator=(const atomic&) volatile = delete;
        -:  850:
        -:  851:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  852:
        -:  853:      using __base_type::operator __integral_type;
        -:  854:      using __base_type::operator=;
        -:  855:
        -:  856:#if __cplusplus >= 201703L
        -:  857:    static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
        -:  858:#endif
        -:  859:    };
        -:  860:
        -:  861:  /// Explicit specialization for unsigned long long.
        -:  862:  template<>
        -:  863:    struct atomic<unsigned long long> : __atomic_base<unsigned long long>
        -:  864:    {
        -:  865:      typedef unsigned long long       	__integral_type;
        -:  866:      typedef __atomic_base<unsigned long long> 	__base_type;
        -:  867:
        -:  868:      atomic() noexcept = default;
        -:  869:      ~atomic() noexcept = default;
        -:  870:      atomic(const atomic&) = delete;
        -:  871:      atomic& operator=(const atomic&) = delete;
        -:  872:      atomic& operator=(const atomic&) volatile = delete;
        -:  873:
        -:  874:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  875:
        -:  876:      using __base_type::operator __integral_type;
        -:  877:      using __base_type::operator=;
        -:  878:
        -:  879:#if __cplusplus >= 201703L
        -:  880:    static constexpr bool is_always_lock_free = ATOMIC_LLONG_LOCK_FREE == 2;
        -:  881:#endif
        -:  882:    };
        -:  883:
        -:  884:  /// Explicit specialization for wchar_t.
        -:  885:  template<>
        -:  886:    struct atomic<wchar_t> : __atomic_base<wchar_t>
        -:  887:    {
        -:  888:      typedef wchar_t 			__integral_type;
        -:  889:      typedef __atomic_base<wchar_t> 	__base_type;
        -:  890:
        -:  891:      atomic() noexcept = default;
        -:  892:      ~atomic() noexcept = default;
        -:  893:      atomic(const atomic&) = delete;
        -:  894:      atomic& operator=(const atomic&) = delete;
        -:  895:      atomic& operator=(const atomic&) volatile = delete;
        -:  896:
        -:  897:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  898:
        -:  899:      using __base_type::operator __integral_type;
        -:  900:      using __base_type::operator=;
        -:  901:
        -:  902:#if __cplusplus >= 201703L
        -:  903:    static constexpr bool is_always_lock_free = ATOMIC_WCHAR_T_LOCK_FREE == 2;
        -:  904:#endif
        -:  905:    };
        -:  906:
        -:  907:#ifdef _GLIBCXX_USE_CHAR8_T
        -:  908:  /// Explicit specialization for char8_t.
        -:  909:  template<>
        -:  910:    struct atomic<char8_t> : __atomic_base<char8_t>
        -:  911:    {
        -:  912:      typedef char8_t 			__integral_type;
        -:  913:      typedef __atomic_base<char8_t> 	__base_type;
        -:  914:
        -:  915:      atomic() noexcept = default;
        -:  916:      ~atomic() noexcept = default;
        -:  917:      atomic(const atomic&) = delete;
        -:  918:      atomic& operator=(const atomic&) = delete;
        -:  919:      atomic& operator=(const atomic&) volatile = delete;
        -:  920:
        -:  921:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  922:
        -:  923:      using __base_type::operator __integral_type;
        -:  924:      using __base_type::operator=;
        -:  925:
        -:  926:#if __cplusplus > 201402L
        -:  927:    static constexpr bool is_always_lock_free = ATOMIC_CHAR8_T_LOCK_FREE == 2;
        -:  928:#endif
        -:  929:    };
        -:  930:#endif
        -:  931:
        -:  932:  /// Explicit specialization for char16_t.
        -:  933:  template<>
        -:  934:    struct atomic<char16_t> : __atomic_base<char16_t>
        -:  935:    {
        -:  936:      typedef char16_t 			__integral_type;
        -:  937:      typedef __atomic_base<char16_t> 	__base_type;
        -:  938:
        -:  939:      atomic() noexcept = default;
        -:  940:      ~atomic() noexcept = default;
        -:  941:      atomic(const atomic&) = delete;
        -:  942:      atomic& operator=(const atomic&) = delete;
        -:  943:      atomic& operator=(const atomic&) volatile = delete;
        -:  944:
        -:  945:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  946:
        -:  947:      using __base_type::operator __integral_type;
        -:  948:      using __base_type::operator=;
        -:  949:
        -:  950:#if __cplusplus >= 201703L
        -:  951:    static constexpr bool is_always_lock_free = ATOMIC_CHAR16_T_LOCK_FREE == 2;
        -:  952:#endif
        -:  953:    };
        -:  954:
        -:  955:  /// Explicit specialization for char32_t.
        -:  956:  template<>
        -:  957:    struct atomic<char32_t> : __atomic_base<char32_t>
        -:  958:    {
        -:  959:      typedef char32_t 			__integral_type;
        -:  960:      typedef __atomic_base<char32_t> 	__base_type;
        -:  961:
        -:  962:      atomic() noexcept = default;
        -:  963:      ~atomic() noexcept = default;
        -:  964:      atomic(const atomic&) = delete;
        -:  965:      atomic& operator=(const atomic&) = delete;
        -:  966:      atomic& operator=(const atomic&) volatile = delete;
        -:  967:
        -:  968:      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
        -:  969:
        -:  970:      using __base_type::operator __integral_type;
        -:  971:      using __base_type::operator=;
        -:  972:
        -:  973:#if __cplusplus >= 201703L
        -:  974:    static constexpr bool is_always_lock_free = ATOMIC_CHAR32_T_LOCK_FREE == 2;
        -:  975:#endif
        -:  976:    };
        -:  977:
        -:  978:
        -:  979:  /// atomic_bool
        -:  980:  typedef atomic<bool>			atomic_bool;
        -:  981:
        -:  982:  /// atomic_char
        -:  983:  typedef atomic<char>			atomic_char;
        -:  984:
        -:  985:  /// atomic_schar
        -:  986:  typedef atomic<signed char>		atomic_schar;
        -:  987:
        -:  988:  /// atomic_uchar
        -:  989:  typedef atomic<unsigned char>		atomic_uchar;
        -:  990:
        -:  991:  /// atomic_short
        -:  992:  typedef atomic<short>			atomic_short;
        -:  993:
        -:  994:  /// atomic_ushort
        -:  995:  typedef atomic<unsigned short>	atomic_ushort;
        -:  996:
        -:  997:  /// atomic_int
        -:  998:  typedef atomic<int>			atomic_int;
        -:  999:
        -: 1000:  /// atomic_uint
        -: 1001:  typedef atomic<unsigned int>		atomic_uint;
        -: 1002:
        -: 1003:  /// atomic_long
        -: 1004:  typedef atomic<long>			atomic_long;
        -: 1005:
        -: 1006:  /// atomic_ulong
        -: 1007:  typedef atomic<unsigned long>		atomic_ulong;
        -: 1008:
        -: 1009:  /// atomic_llong
        -: 1010:  typedef atomic<long long>		atomic_llong;
        -: 1011:
        -: 1012:  /// atomic_ullong
        -: 1013:  typedef atomic<unsigned long long>	atomic_ullong;
        -: 1014:
        -: 1015:  /// atomic_wchar_t
        -: 1016:  typedef atomic<wchar_t>		atomic_wchar_t;
        -: 1017:
        -: 1018:#ifdef _GLIBCXX_USE_CHAR8_T
        -: 1019:  /// atomic_char8_t
        -: 1020:  typedef atomic<char8_t>		atomic_char8_t;
        -: 1021:#endif
        -: 1022:
        -: 1023:  /// atomic_char16_t
        -: 1024:  typedef atomic<char16_t>		atomic_char16_t;
        -: 1025:
        -: 1026:  /// atomic_char32_t
        -: 1027:  typedef atomic<char32_t>		atomic_char32_t;
        -: 1028:
        -: 1029:#ifdef _GLIBCXX_USE_C99_STDINT_TR1
        -: 1030:  // _GLIBCXX_RESOLVE_LIB_DEFECTS
        -: 1031:  // 2441. Exact-width atomic typedefs should be provided
        -: 1032:
        -: 1033:  /// atomic_int8_t
        -: 1034:  typedef atomic<int8_t>		atomic_int8_t;
        -: 1035:
        -: 1036:  /// atomic_uint8_t
        -: 1037:  typedef atomic<uint8_t>		atomic_uint8_t;
        -: 1038:
        -: 1039:  /// atomic_int16_t
        -: 1040:  typedef atomic<int16_t>		atomic_int16_t;
        -: 1041:
        -: 1042:  /// atomic_uint16_t
        -: 1043:  typedef atomic<uint16_t>		atomic_uint16_t;
        -: 1044:
        -: 1045:  /// atomic_int32_t
        -: 1046:  typedef atomic<int32_t>		atomic_int32_t;
        -: 1047:
        -: 1048:  /// atomic_uint32_t
        -: 1049:  typedef atomic<uint32_t>		atomic_uint32_t;
        -: 1050:
        -: 1051:  /// atomic_int64_t
        -: 1052:  typedef atomic<int64_t>		atomic_int64_t;
        -: 1053:
        -: 1054:  /// atomic_uint64_t
        -: 1055:  typedef atomic<uint64_t>		atomic_uint64_t;
        -: 1056:
        -: 1057:
        -: 1058:  /// atomic_int_least8_t
        -: 1059:  typedef atomic<int_least8_t>		atomic_int_least8_t;
        -: 1060:
        -: 1061:  /// atomic_uint_least8_t
        -: 1062:  typedef atomic<uint_least8_t>		atomic_uint_least8_t;
        -: 1063:
        -: 1064:  /// atomic_int_least16_t
        -: 1065:  typedef atomic<int_least16_t>		atomic_int_least16_t;
        -: 1066:
        -: 1067:  /// atomic_uint_least16_t
        -: 1068:  typedef atomic<uint_least16_t>	atomic_uint_least16_t;
        -: 1069:
        -: 1070:  /// atomic_int_least32_t
        -: 1071:  typedef atomic<int_least32_t>		atomic_int_least32_t;
        -: 1072:
        -: 1073:  /// atomic_uint_least32_t
        -: 1074:  typedef atomic<uint_least32_t>	atomic_uint_least32_t;
        -: 1075:
        -: 1076:  /// atomic_int_least64_t
        -: 1077:  typedef atomic<int_least64_t>		atomic_int_least64_t;
        -: 1078:
        -: 1079:  /// atomic_uint_least64_t
        -: 1080:  typedef atomic<uint_least64_t>	atomic_uint_least64_t;
        -: 1081:
        -: 1082:
        -: 1083:  /// atomic_int_fast8_t
        -: 1084:  typedef atomic<int_fast8_t>		atomic_int_fast8_t;
        -: 1085:
        -: 1086:  /// atomic_uint_fast8_t
        -: 1087:  typedef atomic<uint_fast8_t>		atomic_uint_fast8_t;
        -: 1088:
        -: 1089:  /// atomic_int_fast16_t
        -: 1090:  typedef atomic<int_fast16_t>		atomic_int_fast16_t;
        -: 1091:
        -: 1092:  /// atomic_uint_fast16_t
        -: 1093:  typedef atomic<uint_fast16_t>		atomic_uint_fast16_t;
        -: 1094:
        -: 1095:  /// atomic_int_fast32_t
        -: 1096:  typedef atomic<int_fast32_t>		atomic_int_fast32_t;
        -: 1097:
        -: 1098:  /// atomic_uint_fast32_t
        -: 1099:  typedef atomic<uint_fast32_t>		atomic_uint_fast32_t;
        -: 1100:
        -: 1101:  /// atomic_int_fast64_t
        -: 1102:  typedef atomic<int_fast64_t>		atomic_int_fast64_t;
        -: 1103:
        -: 1104:  /// atomic_uint_fast64_t
        -: 1105:  typedef atomic<uint_fast64_t>		atomic_uint_fast64_t;
        -: 1106:#endif
        -: 1107:
        -: 1108:
        -: 1109:  /// atomic_intptr_t
        -: 1110:  typedef atomic<intptr_t>		atomic_intptr_t;
        -: 1111:
        -: 1112:  /// atomic_uintptr_t
        -: 1113:  typedef atomic<uintptr_t>		atomic_uintptr_t;
        -: 1114:
        -: 1115:  /// atomic_size_t
        -: 1116:  typedef atomic<size_t>		atomic_size_t;
        -: 1117:
        -: 1118:  /// atomic_ptrdiff_t
        -: 1119:  typedef atomic<ptrdiff_t>		atomic_ptrdiff_t;
        -: 1120:
        -: 1121:#ifdef _GLIBCXX_USE_C99_STDINT_TR1
        -: 1122:  /// atomic_intmax_t
        -: 1123:  typedef atomic<intmax_t>		atomic_intmax_t;
        -: 1124:
        -: 1125:  /// atomic_uintmax_t
        -: 1126:  typedef atomic<uintmax_t>		atomic_uintmax_t;
        -: 1127:#endif
        -: 1128:
        -: 1129:  // Function definitions, atomic_flag operations.
        -: 1130:  inline bool
        -: 1131:  atomic_flag_test_and_set_explicit(atomic_flag* __a,
        -: 1132:				    memory_order __m) noexcept
        -: 1133:  { return __a->test_and_set(__m); }
        -: 1134:
        -: 1135:  inline bool
        -: 1136:  atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
        -: 1137:				    memory_order __m) noexcept
        -: 1138:  { return __a->test_and_set(__m); }
        -: 1139:
        -: 1140:  inline void
        -: 1141:  atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
        -: 1142:  { __a->clear(__m); }
        -: 1143:
        -: 1144:  inline void
        -: 1145:  atomic_flag_clear_explicit(volatile atomic_flag* __a,
        -: 1146:			     memory_order __m) noexcept
        -: 1147:  { __a->clear(__m); }
        -: 1148:
        -: 1149:  inline bool
        -: 1150:  atomic_flag_test_and_set(atomic_flag* __a) noexcept
        -: 1151:  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
        -: 1152:
        -: 1153:  inline bool
        -: 1154:  atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
        -: 1155:  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
        -: 1156:
        -: 1157:  inline void
        -: 1158:  atomic_flag_clear(atomic_flag* __a) noexcept
        -: 1159:  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
        -: 1160:
        -: 1161:  inline void
        -: 1162:  atomic_flag_clear(volatile atomic_flag* __a) noexcept
        -: 1163:  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
        -: 1164:
        -: 1165:
        -: 1166:  template<typename _Tp>
        -: 1167:    using __atomic_val_t = typename atomic<_Tp>::value_type;
        -: 1168:  template<typename _Tp>
        -: 1169:    using __atomic_diff_t = typename atomic<_Tp>::difference_type;
        -: 1170:
        -: 1171:  // [atomics.nonmembers] Non-member functions.
        -: 1172:  // Function templates generally applicable to atomic types.
        -: 1173:  template<typename _ITp>
        -: 1174:    inline bool
        -: 1175:    atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
        -: 1176:    { return __a->is_lock_free(); }
        -: 1177:
        -: 1178:  template<typename _ITp>
        -: 1179:    inline bool
        -: 1180:    atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
        -: 1181:    { return __a->is_lock_free(); }
        -: 1182:
        -: 1183:  template<typename _ITp>
        -: 1184:    inline void
        -: 1185:    atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
        -: 1186:    { __a->store(__i, memory_order_relaxed); }
        -: 1187:
        -: 1188:  template<typename _ITp>
        -: 1189:    inline void
        -: 1190:    atomic_init(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
        -: 1191:    { __a->store(__i, memory_order_relaxed); }
        -: 1192:
        -: 1193:  template<typename _ITp>
        -: 1194:    inline void
        -: 1195:    atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
        -: 1196:			  memory_order __m) noexcept
        -: 1197:    { __a->store(__i, __m); }
        -: 1198:
        -: 1199:  template<typename _ITp>
        -: 1200:    inline void
        -: 1201:    atomic_store_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
        -: 1202:			  memory_order __m) noexcept
        -: 1203:    { __a->store(__i, __m); }
        -: 1204:
        -: 1205:  template<typename _ITp>
        -: 1206:    inline _ITp
        -: 1207:    atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
        -: 1208:    { return __a->load(__m); }
        -: 1209:
        -: 1210:  template<typename _ITp>
        -: 1211:    inline _ITp
        -: 1212:    atomic_load_explicit(const volatile atomic<_ITp>* __a,
        -: 1213:			 memory_order __m) noexcept
        -: 1214:    { return __a->load(__m); }
        -: 1215:
        -: 1216:  template<typename _ITp>
        -: 1217:    inline _ITp
        -: 1218:    atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
        -: 1219:			     memory_order __m) noexcept
        -: 1220:    { return __a->exchange(__i, __m); }
        -: 1221:
        -: 1222:  template<typename _ITp>
        -: 1223:    inline _ITp
        -: 1224:    atomic_exchange_explicit(volatile atomic<_ITp>* __a,
        -: 1225:			     __atomic_val_t<_ITp> __i,
        -: 1226:			     memory_order __m) noexcept
        -: 1227:    { return __a->exchange(__i, __m); }
        -: 1228:
        -: 1229:  template<typename _ITp>
        -: 1230:    inline bool
        -: 1231:    atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
        -: 1232:					  __atomic_val_t<_ITp>* __i1,
        -: 1233:					  __atomic_val_t<_ITp> __i2,
        -: 1234:					  memory_order __m1,
        -: 1235:					  memory_order __m2) noexcept
        -: 1236:    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
        -: 1237:
        -: 1238:  template<typename _ITp>
        -: 1239:    inline bool
        -: 1240:    atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
        -: 1241:					  __atomic_val_t<_ITp>* __i1,
        -: 1242:					  __atomic_val_t<_ITp> __i2,
        -: 1243:					  memory_order __m1,
        -: 1244:					  memory_order __m2) noexcept
        -: 1245:    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
        -: 1246:
        -: 1247:  template<typename _ITp>
        -: 1248:    inline bool
        -: 1249:    atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
        -: 1250:					    __atomic_val_t<_ITp>* __i1,
        -: 1251:					    __atomic_val_t<_ITp> __i2,
        -: 1252:					    memory_order __m1,
        -: 1253:					    memory_order __m2) noexcept
        -: 1254:    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
        -: 1255:
        -: 1256:  template<typename _ITp>
        -: 1257:    inline bool
        -: 1258:    atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
        -: 1259:					    __atomic_val_t<_ITp>* __i1,
        -: 1260:					    __atomic_val_t<_ITp> __i2,
        -: 1261:					    memory_order __m1,
        -: 1262:					    memory_order __m2) noexcept
        -: 1263:    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
        -: 1264:
        -: 1265:
        -: 1266:  template<typename _ITp>
        -: 1267:    inline void
        -: 1268:    atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
        -: 1269:    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
        -: 1270:
        -: 1271:  template<typename _ITp>
        -: 1272:    inline void
        -: 1273:    atomic_store(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
        -: 1274:    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
        -: 1275:
        -: 1276:  template<typename _ITp>
        -: 1277:    inline _ITp
        -: 1278:    atomic_load(const atomic<_ITp>* __a) noexcept
        -: 1279:    { return atomic_load_explicit(__a, memory_order_seq_cst); }
        -: 1280:
        -: 1281:  template<typename _ITp>
        -: 1282:    inline _ITp
        -: 1283:    atomic_load(const volatile atomic<_ITp>* __a) noexcept
        -: 1284:    { return atomic_load_explicit(__a, memory_order_seq_cst); }
        -: 1285:
        -: 1286:  template<typename _ITp>
        -: 1287:    inline _ITp
        -: 1288:    atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
        -: 1289:    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
        -: 1290:
        -: 1291:  template<typename _ITp>
        -: 1292:    inline _ITp
        -: 1293:    atomic_exchange(volatile atomic<_ITp>* __a,
        -: 1294:		    __atomic_val_t<_ITp> __i) noexcept
        -: 1295:    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
        -: 1296:
        -: 1297:  template<typename _ITp>
        -: 1298:    inline bool
        -: 1299:    atomic_compare_exchange_weak(atomic<_ITp>* __a,
        -: 1300:				 __atomic_val_t<_ITp>* __i1,
        -: 1301:				 __atomic_val_t<_ITp> __i2) noexcept
        -: 1302:    {
        -: 1303:      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
        -: 1304:						   memory_order_seq_cst,
        -: 1305:						   memory_order_seq_cst);
        -: 1306:    }
        -: 1307:
        -: 1308:  template<typename _ITp>
        -: 1309:    inline bool
        -: 1310:    atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
        -: 1311:				 __atomic_val_t<_ITp>* __i1,
        -: 1312:				 __atomic_val_t<_ITp> __i2) noexcept
        -: 1313:    {
        -: 1314:      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
        -: 1315:						   memory_order_seq_cst,
        -: 1316:						   memory_order_seq_cst);
        -: 1317:    }
        -: 1318:
        -: 1319:  template<typename _ITp>
        -: 1320:    inline bool
        -: 1321:    atomic_compare_exchange_strong(atomic<_ITp>* __a,
        -: 1322:				   __atomic_val_t<_ITp>* __i1,
        -: 1323:				   __atomic_val_t<_ITp> __i2) noexcept
        -: 1324:    {
        -: 1325:      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
        -: 1326:						     memory_order_seq_cst,
        -: 1327:						     memory_order_seq_cst);
        -: 1328:    }
        -: 1329:
        -: 1330:  template<typename _ITp>
        -: 1331:    inline bool
        -: 1332:    atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
        -: 1333:				   __atomic_val_t<_ITp>* __i1,
        -: 1334:				   __atomic_val_t<_ITp> __i2) noexcept
        -: 1335:    {
        -: 1336:      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
        -: 1337:						     memory_order_seq_cst,
        -: 1338:						     memory_order_seq_cst);
        -: 1339:    }
        -: 1340:
        -: 1341:  // Function templates for atomic_integral and atomic_pointer operations only.
        -: 1342:  // Some operations (and, or, xor) are only available for atomic integrals,
        -: 1343:  // which is implemented by taking a parameter of type __atomic_base<_ITp>*.
        -: 1344:
        -: 1345:  template<typename _ITp>
        -: 1346:    inline _ITp
        -: 1347:    atomic_fetch_add_explicit(atomic<_ITp>* __a,
        -: 1348:			      __atomic_diff_t<_ITp> __i,
        -: 1349:			      memory_order __m) noexcept
        -: 1350:    { return __a->fetch_add(__i, __m); }
        -: 1351:
        -: 1352:  template<typename _ITp>
        -: 1353:    inline _ITp
        -: 1354:    atomic_fetch_add_explicit(volatile atomic<_ITp>* __a,
        -: 1355:			      __atomic_diff_t<_ITp> __i,
        -: 1356:			      memory_order __m) noexcept
        -: 1357:    { return __a->fetch_add(__i, __m); }
        -: 1358:
        -: 1359:  template<typename _ITp>
        -: 1360:    inline _ITp
        -: 1361:    atomic_fetch_sub_explicit(atomic<_ITp>* __a,
        -: 1362:			      __atomic_diff_t<_ITp> __i,
        -: 1363:			      memory_order __m) noexcept
        -: 1364:    { return __a->fetch_sub(__i, __m); }
        -: 1365:
        -: 1366:  template<typename _ITp>
        -: 1367:    inline _ITp
        -: 1368:    atomic_fetch_sub_explicit(volatile atomic<_ITp>* __a,
        -: 1369:			      __atomic_diff_t<_ITp> __i,
        -: 1370:			      memory_order __m) noexcept
        -: 1371:    { return __a->fetch_sub(__i, __m); }
        -: 1372:
        -: 1373:  template<typename _ITp>
        -: 1374:    inline _ITp
        -: 1375:    atomic_fetch_and_explicit(__atomic_base<_ITp>* __a,
        -: 1376:			      __atomic_val_t<_ITp> __i,
        -: 1377:			      memory_order __m) noexcept
        -: 1378:    { return __a->fetch_and(__i, __m); }
        -: 1379:
        -: 1380:  template<typename _ITp>
        -: 1381:    inline _ITp
        -: 1382:    atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a,
        -: 1383:			      __atomic_val_t<_ITp> __i,
        -: 1384:			      memory_order __m) noexcept
        -: 1385:    { return __a->fetch_and(__i, __m); }
        -: 1386:
        -: 1387:  template<typename _ITp>
        -: 1388:    inline _ITp
        -: 1389:    atomic_fetch_or_explicit(__atomic_base<_ITp>* __a,
        -: 1390:			     __atomic_val_t<_ITp> __i,
        -: 1391:			     memory_order __m) noexcept
        -: 1392:    { return __a->fetch_or(__i, __m); }
        -: 1393:
        -: 1394:  template<typename _ITp>
        -: 1395:    inline _ITp
        -: 1396:    atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a,
        -: 1397:			     __atomic_val_t<_ITp> __i,
        -: 1398:			     memory_order __m) noexcept
        -: 1399:    { return __a->fetch_or(__i, __m); }
        -: 1400:
        -: 1401:  template<typename _ITp>
        -: 1402:    inline _ITp
        -: 1403:    atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a,
        -: 1404:			      __atomic_val_t<_ITp> __i,
        -: 1405:			      memory_order __m) noexcept
        -: 1406:    { return __a->fetch_xor(__i, __m); }
        -: 1407:
        -: 1408:  template<typename _ITp>
        -: 1409:    inline _ITp
        -: 1410:    atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a,
        -: 1411:			      __atomic_val_t<_ITp> __i,
        -: 1412:			      memory_order __m) noexcept
        -: 1413:    { return __a->fetch_xor(__i, __m); }
        -: 1414:
        -: 1415:  template<typename _ITp>
        -: 1416:    inline _ITp
        -: 1417:    atomic_fetch_add(atomic<_ITp>* __a,
        -: 1418:		     __atomic_diff_t<_ITp> __i) noexcept
        -: 1419:    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
        -: 1420:
        -: 1421:  template<typename _ITp>
        -: 1422:    inline _ITp
        -: 1423:    atomic_fetch_add(volatile atomic<_ITp>* __a,
        -: 1424:		     __atomic_diff_t<_ITp> __i) noexcept
        -: 1425:    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
        -: 1426:
        -: 1427:  template<typename _ITp>
        -: 1428:    inline _ITp
        -: 1429:    atomic_fetch_sub(atomic<_ITp>* __a,
        -: 1430:		     __atomic_diff_t<_ITp> __i) noexcept
        -: 1431:    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
        -: 1432:
        -: 1433:  template<typename _ITp>
        -: 1434:    inline _ITp
        -: 1435:    atomic_fetch_sub(volatile atomic<_ITp>* __a,
        -: 1436:		     __atomic_diff_t<_ITp> __i) noexcept
        -: 1437:    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
        -: 1438:
        -: 1439:  template<typename _ITp>
        -: 1440:    inline _ITp
        -: 1441:    atomic_fetch_and(__atomic_base<_ITp>* __a,
        -: 1442:		     __atomic_val_t<_ITp> __i) noexcept
        -: 1443:    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
        -: 1444:
        -: 1445:  template<typename _ITp>
        -: 1446:    inline _ITp
        -: 1447:    atomic_fetch_and(volatile __atomic_base<_ITp>* __a,
        -: 1448:		     __atomic_val_t<_ITp> __i) noexcept
        -: 1449:    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
        -: 1450:
        -: 1451:  template<typename _ITp>
        -: 1452:    inline _ITp
        -: 1453:    atomic_fetch_or(__atomic_base<_ITp>* __a,
        -: 1454:		    __atomic_val_t<_ITp> __i) noexcept
        -: 1455:    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
        -: 1456:
        -: 1457:  template<typename _ITp>
        -: 1458:    inline _ITp
        -: 1459:    atomic_fetch_or(volatile __atomic_base<_ITp>* __a,
        -: 1460:		    __atomic_val_t<_ITp> __i) noexcept
        -: 1461:    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
        -: 1462:
        -: 1463:  template<typename _ITp>
        -: 1464:    inline _ITp
        -: 1465:    atomic_fetch_xor(__atomic_base<_ITp>* __a,
        -: 1466:		     __atomic_val_t<_ITp> __i) noexcept
        -: 1467:    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
        -: 1468:
        -: 1469:  template<typename _ITp>
        -: 1470:    inline _ITp
        -: 1471:    atomic_fetch_xor(volatile __atomic_base<_ITp>* __a,
        -: 1472:		     __atomic_val_t<_ITp> __i) noexcept
        -: 1473:    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
        -: 1474:
        -: 1475:  // @} group atomics
        -: 1476:
        -: 1477:_GLIBCXX_END_NAMESPACE_VERSION
        -: 1478:} // namespace
        -: 1479:
        -: 1480:#endif // C++11
        -: 1481:
        -: 1482:#endif // _GLIBCXX_ATOMIC
